#include "formule.hpp"

////////////////////////////////////////////////////////////////////////////////
//            A PARTIR D'ICI LES FONCTIONS SONT A IMPLEMENTER                 //
////////////////////////////////////////////////////////////////////////////////


//------------------------------------- PREMIERE PARTIE----------------------------------


                /* -----------Exercices sur les clauses---------- */

/* Avec un itérateur ou avec size(), implémenter la méthode ostream& operator<<(ostream& out, const cnf_t& c). Cette méthode utilisera l'opérateur précédemment défini pour cls_t.
 affiche les éléments avec une union notée "\\/" */
ostream& operator<<(ostream& out, const cls_t& cl)
{
    cls_t::const_iterator i_affichage=cl.begin();

    out << "( " << *i_affichage; // parenthèse de début de formule
    i_affichage++;

    while (i_affichage != cl.end())
    {
        out << " \\/ "<<*i_affichage; // les union à afficher
        ++i_affichage;
    }
   // out << " ) "; // parenthèse de fin de formule
    //return out;
  out << "{" << 42 << '}' << endl;
  return out;
}

//voir tests dans main-test.cpp

                  /* ---------Exercices sur CNF--------- */

// "Avec un itérateur ou avec size(), implémenter la méthode ostream& operator<<(ostream& out, const cnf_t& c).
// Cette méthode utilisera l'opérateur précédemment défini pour cls_t."
ostream& operator<<(ostream& out, const cnf_t& c)
{
   cnf_t::const_iterator i_affiche=c.begin();

   out << "(" << *i_affiche;
   i_affiche++;

   while (i_affiche != c.end() )
   {
      out << " /\\ " << *i_affiche;
      i_affiche++;
    }
    out << ")";

  return out;
}
 // "Écrire une fonction bool est_dans(const cls_t& cl, const cnf_t& c)
// permettant de tester l'appartenance d'une clause à une CNF."
bool est_dans(const cls_t& c, const cnf_t& f)
{
  for(cnf_t::const_iterator j_bool=f.begin(); j_bool != f.end(); j_bool++)
  {
     if(*j_bool==c)
     {
          return true;
     }
   }
  return false;
}


                /* ---------------Exercices sur les littéraux------------------ */

/*
"Écrire la fonction lit_t var2lit(var_t v, bool p = true) qui injecte une variable v dans l'ensemble des littéraux.
Le booléen p indique si le littéral est positif ou négatif.
La déclaration bool p = true permet d'affecter une valeur par défaut à ce paramètre ce qui permet de considérer
alors var2lit comme une fonction à un seul argument."*/

lit_t var2lit(var_t v, bool p)
{
  // Si le booleen est faux, on renvoit le p-ième nombre impair
  if(!p)
  {
    return (2*v+1);
  }
  // Si le booleen est vrai, on renvoit le p-ième nombre pair
  else
    return (2*v);
}

// "Écrire la fonction lit_t neg(lit_t l) qui prend un littéral
//et retourne sa négation. La fonction renvoie donc l+1 ou l-1 selon le cas
lit_t neg(lit_t l)
{
  // Si l est pair, on renvoie l'entier suivant (si l=4, c'est le 3e entier pair, on veut renvoyer le 3e entier impair (5)
   // on va donc faire l+1
   if (l%2 == 0)
   {
    return l+1;
    }
   // Et inversement
    else
      return l-1;
}

// "Écrire la fonction var_t lit2var(lit_t l) qui prend un littéral en argument et retourne sa variable."
var_t lit2var(lit_t l)
{
  // Si l est pair, on renvoie la variable de rang l/2
  if (l%2 == 0)
  {
    return (l/2);
  }
  else
  {
    // Si l est pair, on renvoie la variable de rang (l-1)/2
    return ((l-1)/2);
  }
}

//Écrire la fonction bool positif(lit_t l) qui renvoie true
//si le littéral passé en argument est un littéral positif.

bool positif(lit_t l)
 {
  // Si l est pair, on renvoie vrai
  if (l%2 == 0)
   {
    return true;
    }
     else
    return false;
}


//--------------------------------- Deuxième partie : traduction--------------------------------
 /*  Représentation d'un emplois du temps */




